/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"
#include "预设材质.h"

#include "物体/物体.h"
#include "core/引擎配置.h"




bool	S_单色点材质::m_是否以创建着色器 = false;
bool	S_单色面材质::m_是否以创建着色器 = false;
bool	S_单色线框材质::m_是否以创建着色器 = false;
bool	S_单色描边材质::m_是否以创建着色器 = false;
bool	S_单色平直面材质::m_是否以创建着色器 = false;
bool	S_单色线段材质::m_是否以创建着色器 = false;
bool	S_单色连续线材质::m_是否以创建着色器 = false;
bool	S_单色虚线材质::m_是否以创建着色器 = false;


bool	S_基本光照描边材质::m_是否以创建着色器 = false;
bool	S_面基本光照材质::m_是否以创建着色器 = false;
bool	S_线基本光照材质::m_是否以创建着色器 = false;
bool	S_权重可视材质::m_是否以创建着色器 = false;

bool	S_线逐顶点有色材质::m_是否以创建着色器 = false;
bool	S_线逐顶点有色线段材质::m_是否以创建着色器 = false;
bool	S_线逐顶点有色连续线材质::m_是否以创建着色器 = false;
bool	S_扇形线逐顶点有色材质::m_是否以创建着色器 = false;
bool	S_单色逐顶点线描边材质::m_是否以创建着色器 = false;


bool	S_物理光照光追材质::m_是否以创建着色器 = false;



static S_板载缓存* g_骨骼默认缓存_骨骼属性 = nullptr;
static S_板载缓存* g_骨骼默认缓存_骨骼变换 = nullptr;
static S_板载缓存* g_骨骼默认缓存_顶点权重 = nullptr;
static S_板载缓存* g_骨骼默认缓存_骨骼索引 = nullptr;
static S_板载缓存* g_骨骼默认缓存_选中骨骼ID = nullptr;
static S_板载缓存* g_基本光照材质缓存_灯光方向 = nullptr;





static void f_updateGPU单色参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_单色面材质* sm = (S_单色面材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);
	//if (纹理槽数量) f_alloc缓存槽(&layout, 纹理槽数量);
	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_Color;
}





static S_板载缓存* f_创建GPU骨骼属性参数(S_设备环境& ctx) {
	return f_buf_create板载缓存(ctx, sizeof(S_骨骼属性), E_板载缓存类型::e_UBO);
}


static void f_创建骨骼GPU默认参数(S_设备环境& ctx) {
	if (!g_骨骼默认缓存_骨骼属性) {
		g_骨骼默认缓存_骨骼属性 = f_buf_create板载缓存(ctx, sizeof(S_骨骼属性), E_板载缓存类型::e_UBO, 1);
		S_骨骼属性 骨骼属性 = {};
		f_buf_fill板载缓存(g_骨骼默认缓存_骨骼属性, &骨骼属性, 1);
	}
	if (!g_骨骼默认缓存_骨骼变换) g_骨骼默认缓存_骨骼变换 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(Mat44f));
	if (!g_骨骼默认缓存_顶点权重) g_骨骼默认缓存_顶点权重 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(float32));
	if (!g_骨骼默认缓存_骨骼索引) g_骨骼默认缓存_骨骼索引 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(uint32));
	if(!g_骨骼默认缓存_选中骨骼ID) g_骨骼默认缓存_选中骨骼ID = f_buf_create板载缓存(ctx, E_板载缓存类型::e_SSBO, sizeof(uint32));
	if (!g_基本光照材质缓存_灯光方向) {
		g_基本光照材质缓存_灯光方向 = f_buf_create板载缓存(ctx, E_板载缓存类型::e_UBO, sizeof(vec4));
		f_buf_fill板载缓存<vec4>(g_基本光照材质缓存_灯光方向, { {0,1,0,1}, {0,1,0,1}, {0,1,0,1}, {0,1,0,1} }, E_板载缓存类型::e_UBO);
	}
}












static S_线管创建配置 f_单色图元配置() {
	S_线管创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "单色_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "单色_片源阶段.spv", E_着色阶段::e_像素着色},
		},
		{
			{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)},
		}

	};

	return 图元配置;
}
static S_线管创建配置 f_单色平直着色图元配置() {
	S_线管创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{3, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{4, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "单色明暗着色_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "单色明暗着色_几何阶段.spv", E_着色阶段::e_几何着色},
			{S_引擎::m_3D着色器文件根路径 + "单色明暗着色_片源阶段.spv", E_着色阶段::e_像素着色},
		},
		{
			{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)},
		}
	};

	return 图元配置;
}

static void f_updateGPU独立缩放单色着色参数配置(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
	S_单色材质* sm = (S_单色材质*)(mat);

	if (mesh->m_GPU参数布局.m_参数数量 != 5) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 5);

		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
		mesh->m_GPU参数布局.m_绑定位置[1] = 1;

		if (mesh->m_颜色 == nullptr) {
			mesh->m_颜色 = f_buf_create板载缓存(*mat->m_Ctx, E_板载缓存类型::e_SSBO, sizeof(uint32));
			std::vector<S_RGBA8UI> fillData = { {127,127,127,255} };
			f_buf_fill板载缓存(mesh->m_颜色, fillData);
		}
		mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_颜色;
		mesh->m_GPU参数布局.m_绑定位置[2] = 2;

		mesh->m_GPU参数布局.m_参数槽[3] = sm->m_Color;
		mesh->m_GPU参数布局.m_绑定位置[3] = 3;

		mesh->m_GPU参数布局.m_参数槽[4] = sm->m_材质属性;
		mesh->m_GPU参数布局.m_绑定位置[4] = 4;
	}

	if (ob->m_骨架) {
		mesh->m_GPU参数布局.m_参数槽[3] = ob->m_骨架->m_骨骼长度.m_Buf;

		mesh->m_GPU参数布局.m_参数槽[4] = ob->m_独立缩放;
		f_buf_fill板载缓存<S_单色材质属性>(ob->m_独立缩放, { {1, mesh->m_深度控制.x, mesh->m_深度控制.y, 0} }, E_板载缓存类型::e_UBO);
	}
	else {
		mesh->m_GPU参数布局.m_参数槽[3] = sm->m_Color;
		f_buf_fill板载缓存<S_单色材质属性>(sm->m_材质属性, { {0, mesh->m_深度控制.x, mesh->m_深度控制.y, 0} }, E_板载缓存类型::e_UBO);
	}
}


static void f_updateGPU单色着色参数配置(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
	S_单色材质* sm = (S_单色材质*)(mat);

	if (mesh->m_GPU参数布局.m_参数数量 != 3) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 3);

		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
		mesh->m_GPU参数布局.m_绑定位置[1] = 1;

		if (mesh->m_颜色 == nullptr) {
			mesh->m_颜色 = f_buf_create板载缓存(*mat->m_Ctx, E_板载缓存类型::e_SSBO, sizeof(uint32));
			std::vector<uint32> fillData = { f_PackData4X8({ 127,127,127,255 })};
			f_buf_fill板载缓存(mesh->m_颜色, fillData);
		}
		mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_颜色;
		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
	}
}

S_单色材质::S_单色材质(S_设备环境& ctx, bool 独立缩放) : S_材质(&ctx) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { 0xffffffff }, E_板载缓存类型::e_UBO);

	if (独立缩放) {
		m_材质属性 = f_buf_create板载缓存(ctx, sizeof(S_单色材质属性), E_板载缓存类型::e_UBO);
		f_buf_fill板载缓存<S_单色材质属性>(m_材质属性, { {0, 1, 0, 0} }, E_板载缓存类型::e_UBO);

		mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU独立缩放单色着色参数配置;
	}
	else {
		mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU单色着色参数配置;
	}
}

S_单色材质::~S_单色材质() {

}
void S_单色材质::f_set颜色(S_RGBA8UI color) {
	m_Color->f_map();
	*((uint32*)(m_Color->m_mappedPtr)) = f_PackData4X8(color);
	m_Color->f_unmap();
}

S_材质* S_单色材质::f_copy(S_单色材质* mat) {
	mat->m_Pipeline = m_Pipeline;
	mat->m_Shader = m_Shader;
	mat->m_深度遮挡 = m_深度遮挡;
	mat->m_Color = m_Color;
	mat->m_材质属性 = m_材质属性;
	mat->m_GPU参数set = m_GPU参数set;
	mat->mf_GPU参数配置 = mf_GPU参数配置;
	return mat;
}







S_单色点材质::S_单色点材质(S_设备环境& ctx) : S_单色材质(ctx, false) {

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充点;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
	//mf_GPU材质槽更新 = f_updateGPU单色参数布局;
}

S_材质* S_单色点材质::f_copy() {
	S_单色点材质* mat = new S_单色点材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}


S_单色线框材质::S_单色线框材质(S_设备环境& ctx) : S_单色材质(ctx, false) {

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
	//mf_GPU材质槽更新 = f_updateGPU单色参数布局;
}

S_材质* S_单色线框材质::f_copy() {
	S_单色线框材质* mat = new S_单色线框材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}


S_单色面材质::S_单色面材质(S_设备环境& ctx) : S_单色材质(ctx, false) {

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
	//mf_GPU材质槽更新 = f_updateGPU单色参数布局;
}

S_材质* S_单色面材质::f_copy() {
	S_单色点材质* mat = new S_单色点材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}


S_单色平直面材质::S_单色平直面材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;
		//线管参数.m_启用混合 = false;
		//线管参数.m_透明混合模式 = E_混合模式::e_最大;
		//线管参数.m_颜色混合模式 = E_混合模式::e_最大;
		//线管参数.m_目标颜色混合因子 = E_混合因子::e_源一减源透明通道;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
	//mf_GPU材质槽更新 = f_updateGPU单色参数布局;
}

S_材质* S_单色平直面材质::f_copy() {
	S_单色平直面材质* mat = new S_单色平直面材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}



S_单色描边材质::S_单色描边材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		//线管参数.m_启用写入深度 = false;
		//线管参数.m_启用深度边界 = true;
		//线管参数.m_启用深度测试 = false;
		//线管参数.m_颜色混合模式 = E_混合模式::e_最小;
		//线管参数.m_透明混合模式 = E_混合模式::e_最大;
		//线管参数.m_目标颜色混合因子 = E_混合因子::e_混合因子零;

		//线管参数.m_源透明通道因子 = E_混合因子::e_混合因子一;
		//线管参数.m_目标透明通道因子 = E_混合因子::e_混合因子一;
		//线管参数.m_深度偏移 = 10.0;
		//线管参数.m_启用混合 = false;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
	//f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({200, 100, 64, 255}) }, E_板载缓存类型::e_UBO);
}

S_材质* S_单色描边材质::f_copy() {
	S_单色描边材质* mat = new S_单色描边材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}






S_单色线段材质::S_单色线段材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}

	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({200, 200, 200, 255}) }, E_板载缓存类型::e_UBO);
}

S_材质* S_单色线段材质::f_copy() {
	S_单色线段材质* mat = new S_单色线段材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}





S_单色连续线材质::S_单色连续线材质(S_设备环境& ctx) : S_单色材质(ctx, false) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画连续线;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		auto 图元配置 = f_单色图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质* S_单色连续线材质::f_copy() {
	S_单色连续线材质* mat = new S_单色连续线材质(*m_Ctx);
	S_单色材质::f_copy(mat);
	return mat;
}






S_独立缩放单色材质::S_独立缩放单色材质(S_设备环境& ctx, E_绘制方式 绘制方式, E_填充模式 填充模式, bool 写入深度, bool 深度测试, bool 独立缩放)
	: S_单色材质(ctx, 独立缩放), 线管参数({ 1024, 1024 }), m_独立缩放(独立缩放), m_是否以创建着色器(false)
{
	if (!m_是否以创建着色器) {
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = 填充模式;
		
		线管参数.m_采样 = ctx.m_采样数;
		线管参数.m_启用深度测试 = 深度测试;
		线管参数.m_启用写入深度 = 写入深度;

		S_线管创建配置 图元配置;
		if (m_独立缩放) {
			图元配置 = f_单色平直着色图元配置();
		} else {
			图元配置 = f_单色图元配置();
		}
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质* S_独立缩放单色材质::f_copy() {
	S_独立缩放单色材质* mat = new S_独立缩放单色材质(*m_Ctx, 线管参数.m_绘制方式, 线管参数.m_填充模式, 线管参数.m_启用写入深度, 线管参数.m_启用深度测试, m_独立缩放);
	S_单色材质::f_copy(mat);
	return mat;
}






S_单色虚线材质::S_单色虚线材质(S_设备环境& ctx, bool 是否连续) : S_材质(&ctx), m_线管参数({512,512}), m_是否连续(是否连续) {
	if (!m_是否以创建着色器) {
		if (是否连续) {
			m_线管参数.m_绘制方式 = E_绘制方式::e_画连续线;
		}
		else {
			m_线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		}
		
		m_线管参数.m_填充模式 = E_填充模式::e_填充线;
		m_线管参数.m_启用写入深度 = true;
		m_线管参数.m_采样 = ctx.m_采样数;


		S_线管创建配置 图元配置;
		if (m_独立缩放) {
			图元配置 = f_单色平直着色图元配置();
		}
		else {
			图元配置 = f_单色图元配置();
		}
		f_df_创建材质着色器(ctx, this, 图元配置, m_线管参数);

		m_是否以创建着色器 = true;
	}
}

S_材质* S_单色虚线材质::f_copy() {
	S_单色虚线材质* mat = new S_单色虚线材质(*m_Ctx, m_是否连续);
	mat->m_Pipeline = m_Pipeline;
	mat->m_Shader = m_Shader;
	mat->m_深度遮挡 = m_深度遮挡;
	mat->m_GPU参数set = m_GPU参数set;
	mat->mf_GPU参数配置 = mf_GPU参数配置;

	return mat;
}






static void f_updateGPU线逐顶点有色参数布局(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
	S_线逐顶点有色材质* sm = (S_线逐顶点有色材质*)(mat);
	if (mesh->m_GPU参数布局.m_参数数量 != 3) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 3);

		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
		mesh->m_GPU参数布局.m_绑定位置[1] = 1;
	}
	mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_网格元素属性.m_Buf;
	mesh->m_GPU参数布局.m_绑定位置[2] = DEF_BINDING_LineProp;
}

static void f_updateGPU线逐顶点有色线段参数布局(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
	S_线逐顶点有色线段材质* sm = (S_线逐顶点有色线段材质*)(mat);
	if (mesh->m_GPU参数布局.m_参数数量 != 3) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 3);

		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
		mesh->m_GPU参数布局.m_绑定位置[1] = 1;
	}
	mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_网格元素属性.m_Buf;
	mesh->m_GPU参数布局.m_绑定位置[2] = DEF_BINDING_LineProp;
}

static void f_updateGPU线逐顶点有色线参数布局(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
	S_线逐顶点有色线段材质* sm = (S_线逐顶点有色线段材质*)(mat);
	if (mesh->m_GPU参数布局.m_参数数量 != 3) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 3);

		mesh->m_GPU参数布局.m_绑定位置[0] = 0;
		mesh->m_GPU参数布局.m_绑定位置[1] = 1;
	}
	mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_网格元素属性.m_Buf;
	mesh->m_GPU参数布局.m_绑定位置[2] = DEF_BINDING_LineProp;
}

S_线逐顶点有色材质::S_线逐顶点有色材质(S_设备环境& ctx, bool 是否有深度遮挡, E_绘制方式 绘制方式) {
	m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	f_buf_fill板载缓存<S_MeshTranformProp>(m_绘制参数, { MeshProp_Init() }, E_板载缓存类型::e_SSBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用写入深度 = 是否有深度遮挡;


		S_线管创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", E_着色阶段::e_顶点着色},
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)},
			}
		};
		
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色参数布局;
}

void S_线逐顶点有色材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	//f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
}



S_线逐顶点有色线段材质::S_线逐顶点有色线段材质(S_设备环境& ctx, bool 是否有深度遮挡, E_绘制方式 绘制方式, E_填充模式 填充模式) {
	m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	f_buf_fill板载缓存<S_MeshTranformProp>(m_绘制参数, { MeshProp_Init() }, E_板载缓存类型::e_SSBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = 绘制方式;// E_绘制方式::e_画线段;
		线管参数.m_填充模式 = 填充模式;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = 是否有深度遮挡;
		线管参数.m_启用写入深度 = 是否有深度遮挡;

		S_线管创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", E_着色阶段::e_顶点着色},
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)},
			}

		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色线段参数布局;
}

void S_线逐顶点有色线段材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	//f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
}




S_扇形线逐顶点有色材质::S_扇形线逐顶点有色材质(S_设备环境& ctx, bool 是否有深度遮挡) {
	m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	f_buf_fill板载缓存<S_MeshTranformProp>(m_绘制参数, { MeshProp_Init() }, E_板载缓存类型::e_SSBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画扇形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = 是否有深度遮挡;
		线管参数.m_启用写入深度 = 是否有深度遮挡;

		S_线管创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", E_着色阶段::e_顶点着色},
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", E_着色阶段::e_像素着色},
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色参数布局;
}

void S_扇形线逐顶点有色材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
}




S_线逐顶点有色连续线材质::S_线逐顶点有色连续线材质(S_设备环境& ctx, bool 是否有深度遮挡) {
	//m_绘制参数 = f_buf_create板载缓存(ctx, sizeof(S_MeshTranformProp), E_板载缓存类型::e_SSBO);
	//f_buf_fill板载缓存<S_MeshTranformProp>(m_绘制参数, { MeshProp_Init() }, E_板载缓存类型::e_SSBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画连续线;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = 是否有深度遮挡;
		线管参数.m_启用写入深度 = 是否有深度遮挡;

		S_线管创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", E_着色阶段::e_顶点着色},
			    {S_引擎::m_3D着色器文件根路径 + "逐顶点有色_片源阶段.spv", E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)},
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU线逐顶点有色线参数布局;
}

S_线逐顶点有色连续线材质::~S_线逐顶点有色连续线材质() {
}

void S_线逐顶点有色连续线材质::f_set材质参数(float32 绘制距离, uint32 实例ID) {
	//f_buf_fill板载缓存<float32>(m_绘制参数, { 100.0f }, E_板载缓存类型::e_UBO);
}









static S_线管创建配置 f_基本光照图元配置(bool 描边) {
	S_线管创建配置 图元配置;

	std::string 片源着色;
	if (描边) {
		片源着色 = S_引擎::m_3D着色器文件根路径 + "基本光照描边_片源阶段.spv";
	}
	else {
		片源着色 = S_引擎::m_3D着色器文件根路径 + "基本光照_片源阶段.spv";
	}

	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},		//灯光方向
			{DEF_BINDING_WIDGET_Color, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

			{DEF_BINDING_Bones_Props, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	 
			{DEF_BINDING_Bones_Weigth, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	 
			{DEF_BINDING_Bones_Matrix, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	 

			{DEF_BINDING_LineProp, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "基本光照_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{片源着色, E_着色阶段::e_像素着色},
		},
		{
			{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)},
		}
	};

	return 图元配置;
}


static void f_updateGPU基本光照参数_骨骼配置(S_物体* ob, S_Mesh* mesh) {
	//if (纹理槽数量) f_alloc缓存槽(&layout, 纹理槽数量);
	if (ob->m_骨架) {
		mesh->m_GPU参数布局.m_参数槽[4] = mesh->m_骨骼属性->m_Buf;
		mesh->m_GPU参数布局.m_绑定位置[4] = DEF_BINDING_Bones_Props;

		mesh->m_GPU参数布局.m_参数槽[5] = mesh->m_骨骼权重->m_Buf;
		mesh->m_GPU参数布局.m_绑定位置[5] = DEF_BINDING_Bones_Weigth;

		mesh->m_GPU参数布局.m_参数槽[6] = ob->m_骨架->m_骨骼变换.m_Buf;
		mesh->m_GPU参数布局.m_绑定位置[6] = DEF_BINDING_Bones_Matrix;
	}
	else {
		mesh->m_GPU参数布局.m_参数槽[4] = g_骨骼默认缓存_骨骼变换;
		mesh->m_GPU参数布局.m_绑定位置[4] = DEF_BINDING_Bones_Props;

		mesh->m_GPU参数布局.m_参数槽[5] = g_骨骼默认缓存_顶点权重;
		mesh->m_GPU参数布局.m_绑定位置[5] = DEF_BINDING_Bones_Weigth;

		mesh->m_GPU参数布局.m_参数槽[6] = g_骨骼默认缓存_骨骼索引;
		mesh->m_GPU参数布局.m_绑定位置[6] = DEF_BINDING_Bones_Matrix;
	}
	
}

static void f_updateGPU基本光照参数配置(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 槽) {
	S_面基本光照材质* sm = (S_面基本光照材质*)(mat);

	if (mesh->m_GPU参数布局.m_参数数量 != 8) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 8);

		mesh->m_GPU参数布局.m_参数槽[2] = sm->m_灯光方向;
		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
		mesh->m_GPU参数布局.m_参数槽[3] = S_物体::g_物体颜色[槽];
		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
	}
	mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格元素属性.m_Buf;
	mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;

	f_updateGPU基本光照参数_骨骼配置(ob, mesh);
}


//static void f_updateGPU基本光照参数配置_描边(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 槽) {
//	S_面基本光照材质* sm = (S_面基本光照材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_参数数量 != 8) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 8);
//
//		mesh->m_GPU参数布局.m_参数槽[2] = sm->m_灯光方向;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//		mesh->m_GPU参数布局.m_参数槽[3] = S_物体::g_物体颜色[槽];
//		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//	mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格属性.m_Buf;
//	mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;
//
//	f_updateGPU基本光照参数配置(ob, mesh);
//}

//static void f_updateGPU基本光照参数配置_面(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 槽) {
//	S_面基本光照材质* sm = (S_面基本光照材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_参数数量 != 8) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 8);
//
//		mesh->m_GPU参数布局.m_参数槽[2] = sm->m_灯光方向;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//		mesh->m_GPU参数布局.m_参数槽[3] = S_物体::g_物体颜色[槽];
//		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//	mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格属性.m_Buf;
//	mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;
//
//	f_updateGPU基本光照参数配置(ob, mesh);
//}
//
//
//static void f_updateGPU基本光照参数配置_线(S_材质* mat, S_物体* ob, S_Mesh* mesh, uint8 槽) {
//	S_线基本光照材质* sm = (S_线基本光照材质*)(mat);
//
//	if (mesh->m_GPU参数布局.m_参数数量 != 8) {
//		f_alloc缓存槽(&mesh->m_GPU参数布局, 8);
//
//		mesh->m_GPU参数布局.m_参数槽[2] = sm->m_灯光方向;
//		mesh->m_GPU参数布局.m_绑定位置[2] = 2;
//		mesh->m_GPU参数布局.m_参数槽[3] = S_物体::g_物体颜色[槽];
//		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//	mesh->m_GPU参数布局.m_参数槽[7] = mesh->m_网格属性.m_Buf;
//	mesh->m_GPU参数布局.m_绑定位置[7] = DEF_BINDING_LineProp;
//
//	f_updateGPU基本光照参数配置(ob, mesh);
//}

S_基本光照描边材质::S_基本光照描边材质(S_设备环境& ctx, E_绘制方式 绘制方式) {
	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = 绘制方式;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		//线管参数.m_启用写入深度 = false;
		//线管参数.m_启用深度边界 = true;
		//线管参数.m_启用深度测试 = false;
		线管参数.m_深度偏移 = 0.5;


		auto 图元配置	= f_基本光照图元配置(true);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}

	m_灯光方向 = g_基本光照材质缓存_灯光方向;

	//mf_GPU材质槽更新 = f_updateGPU基本光照参数布局;
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
}

S_面基本光照材质::S_面基本光照材质(S_设备环境& ctx) {
	m_灯光方向 = f_buf_create板载缓存(ctx, sizeof(vec4), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<vec4>(m_灯光方向, { {0,1,0,1}, {0,1,0,1}, {0,1,0,1}, {0,1,0,1} }, E_板载缓存类型::e_UBO);


	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充面;
		线管参数.m_采样 = ctx.m_采样数;

		S_线管创建配置 图元配置 = f_基本光照图元配置(false);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	
	//mf_GPU材质槽更新 = f_updateGPU基本光照参数布局;
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
}

void S_面基本光照材质::f_set颜色(S_RGBA8UI color, uint32 实例ID) {
	//m_Color->f_map();
	//((uint32*)(m_Color->m_mappedPtr))[实例ID] = f_PackData4X8(color);
	//m_Color->f_unmap();
}



S_线基本光照材质::S_线基本光照材质(S_设备环境& ctx) {
	m_灯光方向 = f_buf_create板载缓存(ctx, sizeof(vec4), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<vec4>(m_灯光方向, { {0,1,0,1}, {0,1,0,1}, {0,1,0,1}, {0,1,0,1} }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;


		S_线管创建配置 图元配置 = f_基本光照图元配置(false);
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}
	//mf_GPU材质槽更新 = f_updateGPU基本光照参数布局;
	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU基本光照参数配置;
}

void S_线基本光照材质::f_set颜色(S_RGBA8UI color, uint32 实例ID) {
	//m_Color->f_map();
	//((uint32*)(m_Color->m_mappedPtr))[实例ID] = f_PackData4X8(color);
	//m_Color->f_unmap();
}



static S_线管创建配置 f_权重可视图元配置() {
	S_线管创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{DEF_BINDING_Bones_Focus, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//骨骼选中
			{DEF_BINDING_Bones_Props, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//骨骼属性
			{DEF_BINDING_Bones_Weigth, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//顶点指向骨骼ID权重
			{DEF_BINDING_Bones_Matrix, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},	//骨骼变换矩阵
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec2),0,E_数据格式::e_F_R32G32},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "权重_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "权重_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};

	return 图元配置;
}

static void f_updateGPU权重可视参数配置(S_材质* mat, S_物体* ob, S_Mesh* mesh) {
	S_权重可视材质* sm = (S_权重可视材质*)(mat);

	if (mesh->m_GPU参数布局.m_参数数量 != 6) {
		f_alloc缓存槽(&mesh->m_GPU参数布局, 6);
	}
	
	if(mesh->m_选中骨骼ID) mesh->m_GPU参数布局.m_参数槽[2] = mesh->m_选中骨骼ID;
	else mesh->m_GPU参数布局.m_参数槽[2] = g_骨骼默认缓存_选中骨骼ID;
	mesh->m_GPU参数布局.m_绑定位置[2] = 2;


	if (ob->m_骨架) {
		mesh->m_GPU参数布局.m_参数槽[3] = mesh->m_骨骼属性->m_Buf;
		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_Bones_Props;

		mesh->m_GPU参数布局.m_参数槽[4] = mesh->m_骨骼权重->m_Buf;
		mesh->m_GPU参数布局.m_绑定位置[4] = DEF_BINDING_Bones_Weigth;

		mesh->m_GPU参数布局.m_参数槽[5] = ob->m_骨架->m_骨骼变换.m_Buf;
		mesh->m_GPU参数布局.m_绑定位置[5] = DEF_BINDING_Bones_Matrix;
	}
	else {
		mesh->m_GPU参数布局.m_参数槽[3] = g_骨骼默认缓存_骨骼变换;
		mesh->m_GPU参数布局.m_绑定位置[3] = DEF_BINDING_Bones_Props;

		mesh->m_GPU参数布局.m_参数槽[4] = g_骨骼默认缓存_顶点权重;
		mesh->m_GPU参数布局.m_绑定位置[4] = DEF_BINDING_Bones_Weigth;

		mesh->m_GPU参数布局.m_参数槽[5] = g_骨骼默认缓存_骨骼索引;
		mesh->m_GPU参数布局.m_绑定位置[5] = DEF_BINDING_Bones_Matrix;
	}
}

S_权重可视材质::S_权重可视材质(S_设备环境& ctx, E_填充模式 填充模式) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({25, 25, 28, 255}) }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = 填充模式;
		线管参数.m_采样 = ctx.m_采样数;


		S_线管创建配置 图元配置 = f_权重可视图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU权重可视参数配置;
}

S_权重可视材质::~S_权重可视材质() {
	f_buf_release板载缓存(m_Color);
}

/*S_权重可视线材质::S_权重可视线材质(S_设备环境& ctx) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({25, 25, 28, 255}) }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_三角形;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;


		S_着色器创建配置 图元配置 = f_权重可视图元配置();
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

		m_是否以创建着色器 = false;
		f_创建骨骼GPU默认参数(ctx);
	}

	mf_GPU参数配置 = (fp_set材质GPU参数配置)f_updateGPU权重可视参数配置;
}*/











static void f_updateGPU_FLIP可视预览材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_FLIP可视预览材质* sm = (S_FLIP可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);
	
	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_分辨率维度;
	
}

S_FLIP可视预览材质::S_FLIP可视预览材质(S_设备环境& ctx) {
	m_分辨率维度 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
	S_DomProp dim = { {32, 32, 32 }, {32,32,32}, 1 };
	f_buf_fill板载缓存<S_DomProp>(m_分辨率维度, &dim, 1, E_板载缓存类型::e_UBO);

	S_线管创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
			{0, sizeof(float32), 0, E_数据格式::e_F_R32},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "FLIP可视预览_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "FLIP可视预览_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};

	S_线管创建参数 线管参数({ 1024, 1024 });
	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
	线管参数.m_填充模式 = E_填充模式::e_填充面;
	线管参数.m_采样 = ctx.m_采样数;
	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

	mf_GPU材质槽更新 = f_updateGPU_FLIP可视预览材质参数布局;
}










static void f_updateGPU_PBF可视预览材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_PBF可视预览材质* sm = (S_PBF可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);

	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_GPU参数;
}

S_PBF可视预览材质::S_PBF可视预览材质(S_设备环境& ctx) {
	m_GPU参数 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
	vec4 dim = {0.2, 0.2, 1.0, 1.0};
	f_buf_fill板载缓存<vec4>(m_GPU参数, &dim, 1, E_板载缓存类型::e_UBO);

	S_线管创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "PBF可视预览_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "FLIP可视预览_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};

	S_线管创建参数 线管参数({ 1024, 1024 });
	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
	线管参数.m_填充模式 = E_填充模式::e_填充面;
	线管参数.m_采样 = ctx.m_采样数;
	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);

	mf_GPU材质槽更新 = f_updateGPU_PBF可视预览材质参数布局;
}

void S_PBF可视预览材质::f_set颜色(vec4 color, uint32 实例ID) {
	f_buf_fill板载缓存<vec4>(m_GPU参数, &color, 1, E_板载缓存类型::e_UBO);
}









static void f_updateGPU_体素可视网格预览材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_体素可视网格预览材质* sm = (S_体素可视网格预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 2;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);

	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_GPU参数;
	layout.m_参数槽[网格属性缓存槽数量 + 1] = sm->m_颜色;
}

S_体素可视网格预览材质::S_体素可视网格预览材质(S_设备环境& ctx) {
	m_GPU参数 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	S_域绘制属性 dim = { {64,64,64, 1}, {10,10,10, 0.2f}, {0,0,0,0} };
	f_buf_fill板载缓存<S_域绘制属性>(m_GPU参数, &dim, 1, E_板载缓存类型::e_UBO);
	uint32 color = 0xff323232;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);


	S_线管创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{3, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "PBF体素可视预览_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "PBF体素可视预览_几何阶段.spv", E_着色阶段::e_几何着色},
			{S_引擎::m_3D着色器文件根路径 + "PBF体素可视预览_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};


	S_线管创建参数 线管参数({ 1024, 1024 });
	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
	线管参数.m_填充模式 = E_填充模式::e_填充线;
	线管参数.m_采样 = ctx.m_采样数;
	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);


	mf_GPU材质槽更新 = f_updateGPU_体素可视网格预览材质参数布局;

}

void S_体素可视网格预览材质::f_域绘制参数(const S_DomProp& 参数) {
	S_域绘制属性 dim;
	dim.m_世界大小.x = 参数.m_世界大小.x;
	dim.m_世界大小.y = 参数.m_世界大小.y;
	dim.m_世界大小.z = 参数.m_世界大小.z;
	dim.m_世界大小.w = 参数.m_单元大小;

	dim.m_分辨率 = vec_转uv4(参数.m_分辨率);
	dim.m_域世界偏移.x = 参数.m_域世界偏移.x;
	dim.m_域世界偏移.y = 参数.m_域世界偏移.y;
	dim.m_域世界偏移.z = 参数.m_域世界偏移.z;

	f_buf_set<S_域绘制属性>(m_GPU参数, 0, dim);
}






S_八叉树可视预览材质::S_八叉树可视预览材质(S_设备环境& ctx) {
	m_GPU参数 = f_buf_create板载缓存(ctx, sizeof(S_DomProp), E_板载缓存类型::e_UBO);
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	S_DomProp dim = { {64,64,64}, {10,10,10}, 0.2f };
	f_buf_fill板载缓存<S_DomProp>(m_GPU参数, &dim, 1, E_板载缓存类型::e_UBO);
	uint32 color = 0xff323232;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);


	S_线管创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{3, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "PBF体素可视预览_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "八叉树可视预览_几何阶段.spv", E_着色阶段::e_几何着色},
			{S_引擎::m_3D着色器文件根路径 + "PBF体素可视预览_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};


	S_线管创建参数 线管参数({ 1024, 1024 });
	线管参数.m_绘制方式 = E_绘制方式::e_画点集;
	线管参数.m_填充模式 = E_填充模式::e_填充线;
	线管参数.m_采样 = ctx.m_采样数;
	f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);


	mf_GPU材质槽更新 = f_updateGPU_体素可视网格预览材质参数布局;
}

void S_八叉树可视预览材质::f_域绘制参数(const S_DomProp& 参数) {

}











static void f_updateGPU_VecSphere预览材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_VecSphere可视预览材质* sm = (S_VecSphere可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量] = sm->m_颜色;
}

S_VecSphere可视预览材质::S_VecSphere可视预览材质(S_设备环境& ctx) {
	
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	uint32 color = 0xff3232ff;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);



	if (m_Pipeline == nullptr) {
		S_线管创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec4), 0, E_数据格式::e_F_RGBA},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "单色VecSphere_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "单色VecSphere_几何阶段.spv", E_着色阶段::e_几何着色},
			{S_引擎::m_3D着色器文件根路径 + "单色_片源阶段.spv", E_着色阶段::e_像素着色},
		}
		};


		S_线管创建参数 线管参数({ 128, 128 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
	}
	

	mf_GPU材质槽更新 = f_updateGPU_VecSphere预览材质参数布局;
}







static void f_updateGPU_Cube预览材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_Cube可视预览材质* sm = (S_Cube可视预览材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量] = sm->m_颜色;
}

S_Cube可视预览材质::S_Cube可视预览材质(S_设备环境& ctx) {
	m_颜色 = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);

	uint32 color = 0xff3232ff;
	f_buf_fill板载缓存<uint32>(m_颜色, &color, 1, E_板载缓存类型::e_UBO);



	if (m_Pipeline == nullptr) {
		S_线管创建配置 图元配置 = {
		{
			{0, E_着色阶段::e_几何着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_几何着色, E_板载缓存类型::e_SSBO},
			{2, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0, sizeof(vec3), 0, E_数据格式::e_F_RGB},
			{0, sizeof(vec3), 0, E_数据格式::e_F_RGB},
		},
		{
			{S_引擎::m_3D着色器文件根路径 + "单色Cube_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{S_引擎::m_3D着色器文件根路径 + "单色Cube_几何阶段.spv", E_着色阶段::e_几何着色},
			{S_引擎::m_3D着色器文件根路径 + "单色_片源阶段.spv", E_着色阶段::e_像素着色},
		}
		};


		S_线管创建参数 线管参数({ 128, 128 });
		线管参数.m_绘制方式 = E_绘制方式::e_画点集;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;
		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
	}

	mf_GPU材质槽更新 = f_updateGPU_Cube预览材质参数布局;
}








static void f_update单色线描边材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_单色逐顶点线描边材质* sm = (S_单色逐顶点线描边材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != layout.m_参数数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_Color;
}
S_单色逐顶点线描边材质::S_单色逐顶点线描边材质(S_设备环境& ctx) {
	m_Color = f_buf_create板载缓存(ctx, sizeof(uint32), E_板载缓存类型::e_UBO);
	f_buf_fill板载缓存<uint32>(m_Color, { f_PackData4X8({200, 100, 64, 255}) }, E_板载缓存类型::e_UBO);

	if (!m_是否以创建着色器) {
		S_线管创建参数 线管参数({ 1024, 1024 });
		线管参数.m_绘制方式 = E_绘制方式::e_画线段;
		线管参数.m_填充模式 = E_填充模式::e_填充线;
		线管参数.m_采样 = ctx.m_采样数;

		线管参数.m_启用深度测试 = true;
		线管参数.m_启用写入深度 = true;


		S_线管创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},
				{2, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
				{3, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
			},
			{
				{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
				{0,sizeof(uint32),0,E_数据格式::e_UI_R32},
			},
			{
				{S_引擎::m_3D着色器文件根路径 + "逐顶点有色_顶点阶段.spv", E_着色阶段::e_顶点着色},
				{S_引擎::m_3D着色器文件根路径 + "逐顶点描边_片源阶段.spv", E_着色阶段::e_像素着色},
			},
			{
				{E_着色阶段::e_顶点着色, 0, sizeof(S_MeshDrawProp)}
			}
		};

		f_df_创建材质着色器(ctx, this, 图元配置, 线管参数);
		m_是否以创建着色器 = false;
	}

	mf_GPU材质槽更新 = f_update单色线描边材质参数布局;
}

void S_单色逐顶点线描边材质::f_set颜色(S_RGBA8UI color, uint32 实例ID) {
	m_Color->f_map();
	((uint32*)(m_Color->m_mappedPtr))[实例ID] = f_PackData4X8(color);
	m_Color->f_unmap();
}






S_物理光照光追材质::S_物理光照光追材质(S_设备环境& ctx) {
	if (!m_是否以创建着色器) {
		S_线管创建配置 图元配置 = {
			{
				{0, E_着色阶段::e_光追射线生成 | E_着色阶段::e_光追最近相交, E_板载缓存类型::e_光追BVH},
				{1, E_着色阶段::e_顶点着色 | E_着色阶段::e_光追射线生成, E_板载缓存类型::e_IMAGE},
				{2, E_着色阶段::e_光追射线生成 | E_着色阶段::e_光追最近相交 | E_着色阶段::e_光追忽略相交, E_板载缓存类型::e_UBO},
				{3, E_着色阶段::e_光追忽略相交, E_板载缓存类型::e_SSBO},
				{4, E_着色阶段::e_光追忽略相交, E_板载缓存类型::e_SSBO},
			},
			{
			},
			{
				{S_引擎::m_3D着色器文件根路径 + "物理光照_光线生成_rgen.spv", E_着色阶段::e_光追射线生成},
				{S_引擎::m_3D着色器文件根路径 + "物理光照_最近相交_rchit.spv", E_着色阶段::e_光追最近相交},
				{S_引擎::m_3D着色器文件根路径 + "物理光追_光线忽略_rmiss.spv", E_着色阶段::e_光追忽略相交},
			}
		};

		m_Pipeline = f_df_create光追管线(ctx, 图元配置);
	}



}

void f_material_add线属性(S_材质* material, uint32 num) {
	S_线逐顶点有色线段材质* 材质 = dynamic_cast<S_线逐顶点有色线段材质*>(material);
	if (材质) {
		f_buf_resize(材质->m_绘制参数, 材质->m_绘制参数->m_Size + num);
	}
}

void f_material_del线属性(S_材质* material, uint32 ID) {
	S_线逐顶点有色线段材质* 材质 = dynamic_cast<S_线逐顶点有色线段材质*>(material);
	if (材质) {
		
	}
}


void f_material_set线属性(S_材质* material, uint32 ID, const S_MeshTranformProp& 线属性) {
	S_线逐顶点有色线段材质* 材质 = dynamic_cast<S_线逐顶点有色线段材质*>(material);
	if (材质) {
		S_MeshTranformProp* prop = f_buf_map板载缓存<S_MeshTranformProp>(材质->m_绘制参数);
		prop[ID] = 线属性;
		f_buf_unmap板载缓存(材质->m_绘制参数);
	}
}









/*static S_着色器创建配置 f_描边图元配置() {
	S_着色器创建配置 图元配置;

	图元配置 = {
		{
			{0, E_着色阶段::e_顶点着色, E_板载缓存类型::e_UBO},
			{1, E_着色阶段::e_顶点着色, E_板载缓存类型::e_SSBO},

			{2, E_着色阶段::e_像素着色, E_板载缓存类型::e_UBO},
		},
		{
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
			{0,sizeof(vec3),0,E_数据格式::e_F_RGB},
		},
		{
			{"D:/U/Project/engine/材质/着色/compiled/描边_顶点阶段.spv", E_着色阶段::e_顶点着色},
			{"D:/U/Project/engine/材质/着色/compiled/描边_片源阶段.spv", E_着色阶段::e_像素着色},
		}
	};

	return 图元配置;
}*/

//static void f_updateGPU基本光照参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
//	S_基本光照描边材质* sm = (S_基本光照描边材质*)(mat);
//
//	uint16 num = 网格属性缓存槽数量 + 2;
//	if (num != layout.m_参数数量) {
//		f_alloc缓存槽(&layout, num);
//		//if (纹理槽数量) f_alloc缓存槽(&layout, 纹理槽数量);
//		layout.m_参数槽[2] = sm->m_灯光方向;
//		layout.m_绑定位置[2] = 2;
//		layout.m_参数槽[3] = S_物体::g_物体颜色;
//		layout.m_绑定位置[3] = DEF_BINDING_WIDGET_Color;
//	}
//}
/*static void f_updateGPU单色描边材质参数布局(S_材质* mat, S_GPU参数布局& layout, uint16 网格属性缓存槽数量) {
	S_基本光照描边材质* sm = (S_基本光照描边材质*)(mat);

	uint16 num = 网格属性缓存槽数量 + 1;
	if (num != sm->m_参数数量) f_alloc缓存槽(&layout, num);
	layout.m_参数槽[网格属性缓存槽数量 + 0] = sm->m_Color;
}*/





